Tables comprised of columns and rows have long been used in relational database systems. Improvements deriving from deployments of relational database systems have introduced the notion of constraints into the definition and usage of tables. In legacy systems a table might be constructed of rows of data where each row is comprised of several columns, and each column might be defined to represent certain data values. Further, the values in a column might be constrained (e.g., using some form of a given column constraint) such that the values in the given column conform to the given constraint. As an example, the values in a column might be constrained such that no value in that column can be “null”. Other column-wise constraints are present in legacy systems, such as enforcement that a value in a column must be a valid number, or must be a valid date, etc. Moreover some constraints operate over multiple columns in order to enforce the constraint. For example, a multi-column constraint can be described as, “column A must be bigger than column B”. Other constraints involve row constraints in the form of enforcing the constraint over multiple rows. For example, constraints called UNIQUE constraints are used to make sure that no two rows have identically the same values in specific columns. In certain situations, it is desired to define a relation that conforms concurrently to both a set of column constraints as well as to a set of row constraints. And, it is desirable to implement such multi-column/multi-row constraints in an efficient manner. In legacy systems, there are no constraints available that operate concurrently on multiple columns and multiple rows in order to enforce such a multi-column/multi-row constraint.
What is needed are techniques to define and implement multi-column/multi-row constraints in an efficient manner. The deficiency in legacy systems (e.g., the lack of efficient relation constraints that operate concurrently on multiple columns and multiple rows in order to enforce the multi-column/multi-row constraint) is further exacerbated when considering that in an enterprise setting, multiple applications being used by multiple users can operate on the tables concurrently, and thus, what's needed are techniques to handle row insertion requests from multiple concurrently executing processes while still enforcing the validity of the row insertions under the regime of a multi-column/multi-row constraint. Moreover, none of the aforementioned technologies have the capabilities to perform the herein-disclosed high-performance (e.g., minimally-blocking) techniques for implementing a multi-column/multi-row constraint when inserting rows into a relational database table. Therefore, there is a need for improved approaches, some of which approaches are disclosed hereunder.